/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package entityprojet;

import entityprojet.exceptions.IllegalOrphanException;
import entityprojet.exceptions.NonexistentEntityException;
import entityprojet.exceptions.PreexistingEntityException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityNotFoundException;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

/**
 *
 * @author Ron
 */
public class FComptetJpaController implements Serializable {

    public FComptetJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public FComptetJpaController() {
        this.emf = Persistence.createEntityManagerFactory("projetT_RPU");
    }
    
    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(FComptet FComptet) throws PreexistingEntityException, Exception {
        if (FComptet.getFDocenteteCollection() == null) {
            FComptet.setFDocenteteCollection(new ArrayList<FDocentete>());
        }
        if (FComptet.getFDocenteteCollection1() == null) {
            FComptet.setFDocenteteCollection1(new ArrayList<FDocentete>());
        }
        if (FComptet.getFLivraisonCollection() == null) {
            FComptet.setFLivraisonCollection(new ArrayList<FLivraison>());
        }
        if (FComptet.getFCaisseCollection() == null) {
            FComptet.setFCaisseCollection(new ArrayList<FCaisse>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            FCollaborateur cbCONo = FComptet.getCbCONo();
            if (cbCONo != null) {
                cbCONo = em.getReference(cbCONo.getClass(), cbCONo.getCbMarq());
                FComptet.setCbCONo(cbCONo);
            }
            FComptea FComptea = FComptet.getFComptea();
            if (FComptea != null) {
                FComptea = em.getReference(FComptea.getClass(), FComptea.getCbMarq());
                FComptet.setFComptea(FComptea);
            }
            FComptea FComptea1 = FComptet.getFComptea1();
            if (FComptea1 != null) {
                FComptea1 = em.getReference(FComptea1.getClass(), FComptea1.getCbMarq());
                FComptet.setFComptea1(FComptea1);
            }
            FCompteg CGNumPrinc = FComptet.getCGNumPrinc();
            if (CGNumPrinc != null) {
                CGNumPrinc = em.getReference(CGNumPrinc.getClass(), CGNumPrinc.getCbMarq());
                FComptet.setCGNumPrinc(CGNumPrinc);
            }
            FDepot cbDENo = FComptet.getCbDENo();
            if (cbDENo != null) {
                cbDENo = em.getReference(cbDENo.getClass(), cbDENo.getCbMarq());
                FComptet.setCbDENo(cbDENo);
            }
            FEbanque cbEBNo = FComptet.getCbEBNo();
            if (cbEBNo != null) {
                cbEBNo = em.getReference(cbEBNo.getClass(), cbEBNo.getCbMarq());
                FComptet.setCbEBNo(cbEBNo);
            }
            FModeler cbMRNo = FComptet.getCbMRNo();
            if (cbMRNo != null) {
                cbMRNo = em.getReference(cbMRNo.getClass(), cbMRNo.getCbMarq());
                FComptet.setCbMRNo(cbMRNo);
            }
            Collection<FDocentete> attachedFDocenteteCollection = new ArrayList<FDocentete>();
            for (FDocentete FDocenteteCollectionFDocenteteToAttach : FComptet.getFDocenteteCollection()) {
                FDocenteteCollectionFDocenteteToAttach = em.getReference(FDocenteteCollectionFDocenteteToAttach.getClass(), FDocenteteCollectionFDocenteteToAttach.getCbMarq());
                attachedFDocenteteCollection.add(FDocenteteCollectionFDocenteteToAttach);
            }
            FComptet.setFDocenteteCollection(attachedFDocenteteCollection);
            Collection<FDocentete> attachedFDocenteteCollection1 = new ArrayList<FDocentete>();
            for (FDocentete FDocenteteCollection1FDocenteteToAttach : FComptet.getFDocenteteCollection1()) {
                FDocenteteCollection1FDocenteteToAttach = em.getReference(FDocenteteCollection1FDocenteteToAttach.getClass(), FDocenteteCollection1FDocenteteToAttach.getCbMarq());
                attachedFDocenteteCollection1.add(FDocenteteCollection1FDocenteteToAttach);
            }
            FComptet.setFDocenteteCollection1(attachedFDocenteteCollection1);
            Collection<FLivraison> attachedFLivraisonCollection = new ArrayList<FLivraison>();
            for (FLivraison FLivraisonCollectionFLivraisonToAttach : FComptet.getFLivraisonCollection()) {
                FLivraisonCollectionFLivraisonToAttach = em.getReference(FLivraisonCollectionFLivraisonToAttach.getClass(), FLivraisonCollectionFLivraisonToAttach.getCbMarq());
                attachedFLivraisonCollection.add(FLivraisonCollectionFLivraisonToAttach);
            }
            FComptet.setFLivraisonCollection(attachedFLivraisonCollection);
            Collection<FCaisse> attachedFCaisseCollection = new ArrayList<FCaisse>();
            for (FCaisse FCaisseCollectionFCaisseToAttach : FComptet.getFCaisseCollection()) {
                FCaisseCollectionFCaisseToAttach = em.getReference(FCaisseCollectionFCaisseToAttach.getClass(), FCaisseCollectionFCaisseToAttach.getCbMarq());
                attachedFCaisseCollection.add(FCaisseCollectionFCaisseToAttach);
            }
            FComptet.setFCaisseCollection(attachedFCaisseCollection);
            em.persist(FComptet);
            if (cbCONo != null) {
                cbCONo.getFComptetCollection().add(FComptet);
                cbCONo = em.merge(cbCONo);
            }
            if (FComptea != null) {
                FComptea.getFComptetCollection().add(FComptet);
                FComptea = em.merge(FComptea);
            }
            if (FComptea1 != null) {
                FComptea1.getFComptetCollection().add(FComptet);
                FComptea1 = em.merge(FComptea1);
            }
            if (CGNumPrinc != null) {
                CGNumPrinc.getFComptetCollection().add(FComptet);
                CGNumPrinc = em.merge(CGNumPrinc);
            }
            if (cbDENo != null) {
                cbDENo.getFComptetCollection().add(FComptet);
                cbDENo = em.merge(cbDENo);
            }
            if (cbEBNo != null) {
                cbEBNo.getFComptetCollection().add(FComptet);
                cbEBNo = em.merge(cbEBNo);
            }
            if (cbMRNo != null) {
                cbMRNo.getFComptetCollection().add(FComptet);
                cbMRNo = em.merge(cbMRNo);
            }
            for (FDocentete FDocenteteCollectionFDocentete : FComptet.getFDocenteteCollection()) {
                FComptet oldCTNumPayeurOfFDocenteteCollectionFDocentete = FDocenteteCollectionFDocentete.getCTNumPayeur();
                FDocenteteCollectionFDocentete.setCTNumPayeur(FComptet);
                FDocenteteCollectionFDocentete = em.merge(FDocenteteCollectionFDocentete);
                if (oldCTNumPayeurOfFDocenteteCollectionFDocentete != null) {
                    oldCTNumPayeurOfFDocenteteCollectionFDocentete.getFDocenteteCollection().remove(FDocenteteCollectionFDocentete);
                    oldCTNumPayeurOfFDocenteteCollectionFDocentete = em.merge(oldCTNumPayeurOfFDocenteteCollectionFDocentete);
                }
            }
            for (FDocentete FDocenteteCollection1FDocentete : FComptet.getFDocenteteCollection1()) {
                FComptet oldCTNumCentraleOfFDocenteteCollection1FDocentete = FDocenteteCollection1FDocentete.getCTNumCentrale();
                FDocenteteCollection1FDocentete.setCTNumCentrale(FComptet);
                FDocenteteCollection1FDocentete = em.merge(FDocenteteCollection1FDocentete);
                if (oldCTNumCentraleOfFDocenteteCollection1FDocentete != null) {
                    oldCTNumCentraleOfFDocenteteCollection1FDocentete.getFDocenteteCollection1().remove(FDocenteteCollection1FDocentete);
                    oldCTNumCentraleOfFDocenteteCollection1FDocentete = em.merge(oldCTNumCentraleOfFDocenteteCollection1FDocentete);
                }
            }
            for (FLivraison FLivraisonCollectionFLivraison : FComptet.getFLivraisonCollection()) {
                FComptet oldCTNumOfFLivraisonCollectionFLivraison = FLivraisonCollectionFLivraison.getCTNum();
                FLivraisonCollectionFLivraison.setCTNum(FComptet);
                FLivraisonCollectionFLivraison = em.merge(FLivraisonCollectionFLivraison);
                if (oldCTNumOfFLivraisonCollectionFLivraison != null) {
                    oldCTNumOfFLivraisonCollectionFLivraison.getFLivraisonCollection().remove(FLivraisonCollectionFLivraison);
                    oldCTNumOfFLivraisonCollectionFLivraison = em.merge(oldCTNumOfFLivraisonCollectionFLivraison);
                }
            }
            for (FCaisse FCaisseCollectionFCaisse : FComptet.getFCaisseCollection()) {
                FComptet oldCTNumOfFCaisseCollectionFCaisse = FCaisseCollectionFCaisse.getCTNum();
                FCaisseCollectionFCaisse.setCTNum(FComptet);
                FCaisseCollectionFCaisse = em.merge(FCaisseCollectionFCaisse);
                if (oldCTNumOfFCaisseCollectionFCaisse != null) {
                    oldCTNumOfFCaisseCollectionFCaisse.getFCaisseCollection().remove(FCaisseCollectionFCaisse);
                    oldCTNumOfFCaisseCollectionFCaisse = em.merge(oldCTNumOfFCaisseCollectionFCaisse);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findFComptet(FComptet.getCbMarq()) != null) {
                throw new PreexistingEntityException("FComptet " + FComptet + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(FComptet FComptet) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            FComptet persistentFComptet = em.find(FComptet.class, FComptet.getCbMarq());
            FCollaborateur cbCONoOld = persistentFComptet.getCbCONo();
            FCollaborateur cbCONoNew = FComptet.getCbCONo();
            FComptea FCompteaOld = persistentFComptet.getFComptea();
            FComptea FCompteaNew = FComptet.getFComptea();
            FComptea FComptea1Old = persistentFComptet.getFComptea1();
            FComptea FComptea1New = FComptet.getFComptea1();
            FCompteg CGNumPrincOld = persistentFComptet.getCGNumPrinc();
            FCompteg CGNumPrincNew = FComptet.getCGNumPrinc();
            FDepot cbDENoOld = persistentFComptet.getCbDENo();
            FDepot cbDENoNew = FComptet.getCbDENo();
            FEbanque cbEBNoOld = persistentFComptet.getCbEBNo();
            FEbanque cbEBNoNew = FComptet.getCbEBNo();
            FModeler cbMRNoOld = persistentFComptet.getCbMRNo();
            FModeler cbMRNoNew = FComptet.getCbMRNo();
            Collection<FDocentete> FDocenteteCollectionOld = persistentFComptet.getFDocenteteCollection();
            Collection<FDocentete> FDocenteteCollectionNew = FComptet.getFDocenteteCollection();
            Collection<FDocentete> FDocenteteCollection1Old = persistentFComptet.getFDocenteteCollection1();
            Collection<FDocentete> FDocenteteCollection1New = FComptet.getFDocenteteCollection1();
            Collection<FLivraison> FLivraisonCollectionOld = persistentFComptet.getFLivraisonCollection();
            Collection<FLivraison> FLivraisonCollectionNew = FComptet.getFLivraisonCollection();
            Collection<FCaisse> FCaisseCollectionOld = persistentFComptet.getFCaisseCollection();
            Collection<FCaisse> FCaisseCollectionNew = FComptet.getFCaisseCollection();
            List<String> illegalOrphanMessages = null;
            for (FLivraison FLivraisonCollectionOldFLivraison : FLivraisonCollectionOld) {
                if (!FLivraisonCollectionNew.contains(FLivraisonCollectionOldFLivraison)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain FLivraison " + FLivraisonCollectionOldFLivraison + " since its CTNum field is not nullable.");
                }
            }
            for (FCaisse FCaisseCollectionOldFCaisse : FCaisseCollectionOld) {
                if (!FCaisseCollectionNew.contains(FCaisseCollectionOldFCaisse)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain FCaisse " + FCaisseCollectionOldFCaisse + " since its CTNum field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (cbCONoNew != null) {
                cbCONoNew = em.getReference(cbCONoNew.getClass(), cbCONoNew.getCbMarq());
                FComptet.setCbCONo(cbCONoNew);
            }
            if (FCompteaNew != null) {
                FCompteaNew = em.getReference(FCompteaNew.getClass(), FCompteaNew.getCbMarq());
                FComptet.setFComptea(FCompteaNew);
            }
            if (FComptea1New != null) {
                FComptea1New = em.getReference(FComptea1New.getClass(), FComptea1New.getCbMarq());
                FComptet.setFComptea1(FComptea1New);
            }
            if (CGNumPrincNew != null) {
                CGNumPrincNew = em.getReference(CGNumPrincNew.getClass(), CGNumPrincNew.getCbMarq());
                FComptet.setCGNumPrinc(CGNumPrincNew);
            }
            if (cbDENoNew != null) {
                cbDENoNew = em.getReference(cbDENoNew.getClass(), cbDENoNew.getCbMarq());
                FComptet.setCbDENo(cbDENoNew);
            }
            if (cbEBNoNew != null) {
                cbEBNoNew = em.getReference(cbEBNoNew.getClass(), cbEBNoNew.getCbMarq());
                FComptet.setCbEBNo(cbEBNoNew);
            }
            if (cbMRNoNew != null) {
                cbMRNoNew = em.getReference(cbMRNoNew.getClass(), cbMRNoNew.getCbMarq());
                FComptet.setCbMRNo(cbMRNoNew);
            }
            Collection<FDocentete> attachedFDocenteteCollectionNew = new ArrayList<FDocentete>();
            for (FDocentete FDocenteteCollectionNewFDocenteteToAttach : FDocenteteCollectionNew) {
                FDocenteteCollectionNewFDocenteteToAttach = em.getReference(FDocenteteCollectionNewFDocenteteToAttach.getClass(), FDocenteteCollectionNewFDocenteteToAttach.getCbMarq());
                attachedFDocenteteCollectionNew.add(FDocenteteCollectionNewFDocenteteToAttach);
            }
            FDocenteteCollectionNew = attachedFDocenteteCollectionNew;
            FComptet.setFDocenteteCollection(FDocenteteCollectionNew);
            Collection<FDocentete> attachedFDocenteteCollection1New = new ArrayList<FDocentete>();
            for (FDocentete FDocenteteCollection1NewFDocenteteToAttach : FDocenteteCollection1New) {
                FDocenteteCollection1NewFDocenteteToAttach = em.getReference(FDocenteteCollection1NewFDocenteteToAttach.getClass(), FDocenteteCollection1NewFDocenteteToAttach.getCbMarq());
                attachedFDocenteteCollection1New.add(FDocenteteCollection1NewFDocenteteToAttach);
            }
            FDocenteteCollection1New = attachedFDocenteteCollection1New;
            FComptet.setFDocenteteCollection1(FDocenteteCollection1New);
            Collection<FLivraison> attachedFLivraisonCollectionNew = new ArrayList<FLivraison>();
            for (FLivraison FLivraisonCollectionNewFLivraisonToAttach : FLivraisonCollectionNew) {
                FLivraisonCollectionNewFLivraisonToAttach = em.getReference(FLivraisonCollectionNewFLivraisonToAttach.getClass(), FLivraisonCollectionNewFLivraisonToAttach.getCbMarq());
                attachedFLivraisonCollectionNew.add(FLivraisonCollectionNewFLivraisonToAttach);
            }
            FLivraisonCollectionNew = attachedFLivraisonCollectionNew;
            FComptet.setFLivraisonCollection(FLivraisonCollectionNew);
            Collection<FCaisse> attachedFCaisseCollectionNew = new ArrayList<FCaisse>();
            for (FCaisse FCaisseCollectionNewFCaisseToAttach : FCaisseCollectionNew) {
                FCaisseCollectionNewFCaisseToAttach = em.getReference(FCaisseCollectionNewFCaisseToAttach.getClass(), FCaisseCollectionNewFCaisseToAttach.getCbMarq());
                attachedFCaisseCollectionNew.add(FCaisseCollectionNewFCaisseToAttach);
            }
            FCaisseCollectionNew = attachedFCaisseCollectionNew;
            FComptet.setFCaisseCollection(FCaisseCollectionNew);
            FComptet = em.merge(FComptet);
            if (cbCONoOld != null && !cbCONoOld.equals(cbCONoNew)) {
                cbCONoOld.getFComptetCollection().remove(FComptet);
                cbCONoOld = em.merge(cbCONoOld);
            }
            if (cbCONoNew != null && !cbCONoNew.equals(cbCONoOld)) {
                cbCONoNew.getFComptetCollection().add(FComptet);
                cbCONoNew = em.merge(cbCONoNew);
            }
            if (FCompteaOld != null && !FCompteaOld.equals(FCompteaNew)) {
                FCompteaOld.getFComptetCollection().remove(FComptet);
                FCompteaOld = em.merge(FCompteaOld);
            }
            if (FCompteaNew != null && !FCompteaNew.equals(FCompteaOld)) {
                FCompteaNew.getFComptetCollection().add(FComptet);
                FCompteaNew = em.merge(FCompteaNew);
            }
            if (FComptea1Old != null && !FComptea1Old.equals(FComptea1New)) {
                FComptea1Old.getFComptetCollection().remove(FComptet);
                FComptea1Old = em.merge(FComptea1Old);
            }
            if (FComptea1New != null && !FComptea1New.equals(FComptea1Old)) {
                FComptea1New.getFComptetCollection().add(FComptet);
                FComptea1New = em.merge(FComptea1New);
            }
            if (CGNumPrincOld != null && !CGNumPrincOld.equals(CGNumPrincNew)) {
                CGNumPrincOld.getFComptetCollection().remove(FComptet);
                CGNumPrincOld = em.merge(CGNumPrincOld);
            }
            if (CGNumPrincNew != null && !CGNumPrincNew.equals(CGNumPrincOld)) {
                CGNumPrincNew.getFComptetCollection().add(FComptet);
                CGNumPrincNew = em.merge(CGNumPrincNew);
            }
            if (cbDENoOld != null && !cbDENoOld.equals(cbDENoNew)) {
                cbDENoOld.getFComptetCollection().remove(FComptet);
                cbDENoOld = em.merge(cbDENoOld);
            }
            if (cbDENoNew != null && !cbDENoNew.equals(cbDENoOld)) {
                cbDENoNew.getFComptetCollection().add(FComptet);
                cbDENoNew = em.merge(cbDENoNew);
            }
            if (cbEBNoOld != null && !cbEBNoOld.equals(cbEBNoNew)) {
                cbEBNoOld.getFComptetCollection().remove(FComptet);
                cbEBNoOld = em.merge(cbEBNoOld);
            }
            if (cbEBNoNew != null && !cbEBNoNew.equals(cbEBNoOld)) {
                cbEBNoNew.getFComptetCollection().add(FComptet);
                cbEBNoNew = em.merge(cbEBNoNew);
            }
            if (cbMRNoOld != null && !cbMRNoOld.equals(cbMRNoNew)) {
                cbMRNoOld.getFComptetCollection().remove(FComptet);
                cbMRNoOld = em.merge(cbMRNoOld);
            }
            if (cbMRNoNew != null && !cbMRNoNew.equals(cbMRNoOld)) {
                cbMRNoNew.getFComptetCollection().add(FComptet);
                cbMRNoNew = em.merge(cbMRNoNew);
            }
            for (FDocentete FDocenteteCollectionOldFDocentete : FDocenteteCollectionOld) {
                if (!FDocenteteCollectionNew.contains(FDocenteteCollectionOldFDocentete)) {
                    FDocenteteCollectionOldFDocentete.setCTNumPayeur(null);
                    FDocenteteCollectionOldFDocentete = em.merge(FDocenteteCollectionOldFDocentete);
                }
            }
            for (FDocentete FDocenteteCollectionNewFDocentete : FDocenteteCollectionNew) {
                if (!FDocenteteCollectionOld.contains(FDocenteteCollectionNewFDocentete)) {
                    FComptet oldCTNumPayeurOfFDocenteteCollectionNewFDocentete = FDocenteteCollectionNewFDocentete.getCTNumPayeur();
                    FDocenteteCollectionNewFDocentete.setCTNumPayeur(FComptet);
                    FDocenteteCollectionNewFDocentete = em.merge(FDocenteteCollectionNewFDocentete);
                    if (oldCTNumPayeurOfFDocenteteCollectionNewFDocentete != null && !oldCTNumPayeurOfFDocenteteCollectionNewFDocentete.equals(FComptet)) {
                        oldCTNumPayeurOfFDocenteteCollectionNewFDocentete.getFDocenteteCollection().remove(FDocenteteCollectionNewFDocentete);
                        oldCTNumPayeurOfFDocenteteCollectionNewFDocentete = em.merge(oldCTNumPayeurOfFDocenteteCollectionNewFDocentete);
                    }
                }
            }
            for (FDocentete FDocenteteCollection1OldFDocentete : FDocenteteCollection1Old) {
                if (!FDocenteteCollection1New.contains(FDocenteteCollection1OldFDocentete)) {
                    FDocenteteCollection1OldFDocentete.setCTNumCentrale(null);
                    FDocenteteCollection1OldFDocentete = em.merge(FDocenteteCollection1OldFDocentete);
                }
            }
            for (FDocentete FDocenteteCollection1NewFDocentete : FDocenteteCollection1New) {
                if (!FDocenteteCollection1Old.contains(FDocenteteCollection1NewFDocentete)) {
                    FComptet oldCTNumCentraleOfFDocenteteCollection1NewFDocentete = FDocenteteCollection1NewFDocentete.getCTNumCentrale();
                    FDocenteteCollection1NewFDocentete.setCTNumCentrale(FComptet);
                    FDocenteteCollection1NewFDocentete = em.merge(FDocenteteCollection1NewFDocentete);
                    if (oldCTNumCentraleOfFDocenteteCollection1NewFDocentete != null && !oldCTNumCentraleOfFDocenteteCollection1NewFDocentete.equals(FComptet)) {
                        oldCTNumCentraleOfFDocenteteCollection1NewFDocentete.getFDocenteteCollection1().remove(FDocenteteCollection1NewFDocentete);
                        oldCTNumCentraleOfFDocenteteCollection1NewFDocentete = em.merge(oldCTNumCentraleOfFDocenteteCollection1NewFDocentete);
                    }
                }
            }
            for (FLivraison FLivraisonCollectionNewFLivraison : FLivraisonCollectionNew) {
                if (!FLivraisonCollectionOld.contains(FLivraisonCollectionNewFLivraison)) {
                    FComptet oldCTNumOfFLivraisonCollectionNewFLivraison = FLivraisonCollectionNewFLivraison.getCTNum();
                    FLivraisonCollectionNewFLivraison.setCTNum(FComptet);
                    FLivraisonCollectionNewFLivraison = em.merge(FLivraisonCollectionNewFLivraison);
                    if (oldCTNumOfFLivraisonCollectionNewFLivraison != null && !oldCTNumOfFLivraisonCollectionNewFLivraison.equals(FComptet)) {
                        oldCTNumOfFLivraisonCollectionNewFLivraison.getFLivraisonCollection().remove(FLivraisonCollectionNewFLivraison);
                        oldCTNumOfFLivraisonCollectionNewFLivraison = em.merge(oldCTNumOfFLivraisonCollectionNewFLivraison);
                    }
                }
            }
            for (FCaisse FCaisseCollectionNewFCaisse : FCaisseCollectionNew) {
                if (!FCaisseCollectionOld.contains(FCaisseCollectionNewFCaisse)) {
                    FComptet oldCTNumOfFCaisseCollectionNewFCaisse = FCaisseCollectionNewFCaisse.getCTNum();
                    FCaisseCollectionNewFCaisse.setCTNum(FComptet);
                    FCaisseCollectionNewFCaisse = em.merge(FCaisseCollectionNewFCaisse);
                    if (oldCTNumOfFCaisseCollectionNewFCaisse != null && !oldCTNumOfFCaisseCollectionNewFCaisse.equals(FComptet)) {
                        oldCTNumOfFCaisseCollectionNewFCaisse.getFCaisseCollection().remove(FCaisseCollectionNewFCaisse);
                        oldCTNumOfFCaisseCollectionNewFCaisse = em.merge(oldCTNumOfFCaisseCollectionNewFCaisse);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = FComptet.getCbMarq();
                if (findFComptet(id) == null) {
                    throw new NonexistentEntityException("The fComptet with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            FComptet FComptet;
            try {
                FComptet = em.getReference(FComptet.class, id);
                FComptet.getCbMarq();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The FComptet with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Collection<FLivraison> FLivraisonCollectionOrphanCheck = FComptet.getFLivraisonCollection();
            for (FLivraison FLivraisonCollectionOrphanCheckFLivraison : FLivraisonCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This FComptet (" + FComptet + ") cannot be destroyed since the FLivraison " + FLivraisonCollectionOrphanCheckFLivraison + " in its FLivraisonCollection field has a non-nullable CTNum field.");
            }
            Collection<FCaisse> FCaisseCollectionOrphanCheck = FComptet.getFCaisseCollection();
            for (FCaisse FCaisseCollectionOrphanCheckFCaisse : FCaisseCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This FComptet (" + FComptet + ") cannot be destroyed since the FCaisse " + FCaisseCollectionOrphanCheckFCaisse + " in its FCaisseCollection field has a non-nullable CTNum field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            FCollaborateur cbCONo = FComptet.getCbCONo();
            if (cbCONo != null) {
                cbCONo.getFComptetCollection().remove(FComptet);
                cbCONo = em.merge(cbCONo);
            }
            FComptea FComptea = FComptet.getFComptea();
            if (FComptea != null) {
                FComptea.getFComptetCollection().remove(FComptet);
                FComptea = em.merge(FComptea);
            }
            FComptea FComptea1 = FComptet.getFComptea1();
            if (FComptea1 != null) {
                FComptea1.getFComptetCollection().remove(FComptet);
                FComptea1 = em.merge(FComptea1);
            }
            FCompteg CGNumPrinc = FComptet.getCGNumPrinc();
            if (CGNumPrinc != null) {
                CGNumPrinc.getFComptetCollection().remove(FComptet);
                CGNumPrinc = em.merge(CGNumPrinc);
            }
            FDepot cbDENo = FComptet.getCbDENo();
            if (cbDENo != null) {
                cbDENo.getFComptetCollection().remove(FComptet);
                cbDENo = em.merge(cbDENo);
            }
            FEbanque cbEBNo = FComptet.getCbEBNo();
            if (cbEBNo != null) {
                cbEBNo.getFComptetCollection().remove(FComptet);
                cbEBNo = em.merge(cbEBNo);
            }
            FModeler cbMRNo = FComptet.getCbMRNo();
            if (cbMRNo != null) {
                cbMRNo.getFComptetCollection().remove(FComptet);
                cbMRNo = em.merge(cbMRNo);
            }
            Collection<FDocentete> FDocenteteCollection = FComptet.getFDocenteteCollection();
            for (FDocentete FDocenteteCollectionFDocentete : FDocenteteCollection) {
                FDocenteteCollectionFDocentete.setCTNumPayeur(null);
                FDocenteteCollectionFDocentete = em.merge(FDocenteteCollectionFDocentete);
            }
            Collection<FDocentete> FDocenteteCollection1 = FComptet.getFDocenteteCollection1();
            for (FDocentete FDocenteteCollection1FDocentete : FDocenteteCollection1) {
                FDocenteteCollection1FDocentete.setCTNumCentrale(null);
                FDocenteteCollection1FDocentete = em.merge(FDocenteteCollection1FDocentete);
            }
            em.remove(FComptet);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<FComptet> findFComptetEntities() {
        return findFComptetEntities(true, -1, -1);
    }

    public List<FComptet> findFComptetEntities(int maxResults, int firstResult) {
        return findFComptetEntities(false, maxResults, firstResult);
    }

    private List<FComptet> findFComptetEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(FComptet.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public FComptet findFComptet(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(FComptet.class, id);
        } finally {
            em.close();
        }
    }

    public int getFComptetCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<FComptet> rt = cq.from(FComptet.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
